package com.moxi.mogublog.web.filter;

import com.moxi.mogublog.commons.entity.SensitiveWord;
import com.moxi.mogublog.utils.StringUtils;
import com.moxi.mogublog.xo.service.SensitiveWordService;
import org.apache.commons.lang.CharUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Classname SensitiveFilter
 * @Description 敏感词过滤类
 *  前缀树(字典树):用于判断字符串是否存在或者是否具有某种字符串前缀。
 *  它有三个基本性质
 *  1. 根节点不包含字符，除根节点外每一个节点都只包含一个字符.
 *  2. 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串
 * 3. 每个节点的所有子节点包含的字符都不相同。
 *
 *  字典树的插入，删除和查找都非常简单，用一个一重循环即可。
 *  1. 从根节点开始一次搜索
 *  2. 取得要查找关键词的第一个字母，并根据该字母选择对应的子树并转到该子树继续进行检索
 *  3. 在相应的子树上，取得要查找关键词的第二个字母，并进一步选择对应的子树进行检索
 *  4. 迭代上述过程…
 * 5. 在某个节点处，关键词的所有字母已被取出，则读取附在该节点上的信息，即完成查找
 *  *
 *  *- 名称:Trie 字典树 查找树
 *  - 特点:查找效率高 消耗内存大
 *  - 应用:字符串检索 词频统计 字符串排序等
 *  - 定义前缀树
 *  - 根据敏感词 初始化前缀树
 *  - 编写过滤敏感词的方法
 * @Date 2020/11/15 11:14
 * @Created by xiaok
 */

@Component // 构造对象的时候需要构造敏感树
public class SensitiveFilter implements InitializingBean {

    private static final Logger logger = LoggerFactory.getLogger(SensitiveFilter.class);



    @Autowired
    private SensitiveWordService sensitiveWordService;
    //默认敏感词替换符
    private static final String DEFAULT_REPLACEMENT = "***";


    // 根节点
    private TrieNode rootNode= null;

    /**
     * 启动项目时, 读取配置文件中的敏感词
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        try {
        rootNode = new TrieNode();
        //获取敏感词
        List<SensitiveWord> sensitiveWordList = sensitiveWordService.list();
        for (SensitiveWord sensitiveWord:
                sensitiveWordList) {
            // 构造敏感词
            addWord(sensitiveWord.getSensitiveword());
            }
        } catch (Exception e) {
            logger.error("读取敏感词文件失败" + e.getMessage());
        }
    }


    /**
     * 过滤敏感词
     * @param text
     * @return
     */
    public String filter(String text) {
        if (StringUtils.isBlank(text)) {
            return text;
        }
        String replacement = DEFAULT_REPLACEMENT; //替换的字符
        StringBuilder result = new StringBuilder();
        TrieNode tempNode = rootNode;  //指针1
        int begin = 0; // 回滚指针,指针2
        int position = 0; // 当前比较的位置 指针3

        while (position < text.length()) {
            char c = text.charAt(position);
            // 跳过符号
            if (isSymbol(c)) {
                // 若指针1处于根节点,非敏感词字符(将此符号计入结果),让指针2向下走一步
                if (tempNode == rootNode) {
                    result.append(c);
                    ++begin;
                }
                // 无论符号在开头或
                // 中间,指针3都向下走一步
                ++position;
                continue;
            }

            tempNode = tempNode.getSubNode(c); //根节点开始获取子节点关键字

            // 当前位置的匹配结束
            if (tempNode == null) { //
                // 以begin开始的字符串不存在敏感词
                result.append(text.charAt(begin));
                // 跳到下一个字符开始测试
                position = begin + 1;
                begin = position;
                // 回到树初始节点
                tempNode = rootNode;
            } else if (tempNode.isKeywordEnd()) { //发现敏感词
                // 从begin到position的位置用replacement替换掉
                result.append(replacement);
                begin = ++position; //position先加1,然后在赋值begin
                tempNode = rootNode;//回到根节点
            } else {
                ++position;
            }
        }
        //添加 begin- 末尾的字符
        result.append(text.substring(begin));
        return result.toString();
    }

    /**
     * 构造敏感词
     * @param sensitiveword
     */
    private void addWord(String sensitiveword) {
        TrieNode tempNode = this.rootNode; //根节点为空
        for (int i = 0; i < sensitiveword.length(); i++) {
            Character c = sensitiveword.charAt(i);
            // 过滤空格和字符
            if (isSymbol(c)) {
                continue;
            }
            TrieNode node = tempNode.getSubNode(c);

            if (node == null) { // 没初始化
                node = new TrieNode();
                tempNode.addSubNode(c, node);
            }

            tempNode = node;

            if (i == sensitiveword.length() - 1) {
                // 关键词结束， 设置结束标志
                tempNode.setKeyWordEnd(true);
            }
        }
    }


    /**
     * 判断是否是一个符号
     * @param c
     * @return
     */
    private boolean isSymbol(char c) {
        int ic = (int) c;
        // 0x2E80-0x9FFF 东亚文字范围
        return !CharUtils.isAsciiAlphanumeric(c) && (ic < 0x2E80 || ic > 0x9FFF);
    }



    /**
     * 前缀树
     */
    private class TrieNode {
        /**
         * 是否为结束节点
         */
        private boolean end = false;
        /**
         * 子节点集合
         */
        private Map<Character, TrieNode> subTrieNodes = new HashMap<Character, TrieNode>();

        /**
         * 获取下个节点
         * @param key
         * @return
         */
        TrieNode getSubNode(Character key ){
            return subTrieNodes.get(key);
        }

        /**
         * 向指定位置添加节点树
         * @param key
         * @param node
         */
        void  addSubNode(Character key, TrieNode node){
            subTrieNodes.put(key,node);
        }

        /**
         * 是否为关键字
         * @return
         */
        boolean isKeywordEnd(){
            return end;
        }

        /**
         * 设置当前节点是否为关键字
         * @param end
         */
        void setKeyWordEnd(boolean end){
             this.end = end;
        }
        /**
         * 获取当前节点的所有子节点
         * @return
         */
        public int getSubNodeCount() {
            return subTrieNodes.size();
        }



    }

}
